local vssid                    = "test"
local utils                    = require "gcs.utils"
local err_utils                = require "gcs.upload.error_utils"
local red_method               = require "gcs.list.method"
local mongo_method             = require "gcs.mongodb.method"

local multipart                = require "resty.gcsdfs.multipart"
local up_utils                 = require "gcs.upload.upload_utils"
local up_hex                   = require "gcs.upload.hex"
local db_method                = require "gcs.db.method"
local cjson                    = require "cjson"
local resty_uuid               = require "resty.uuid"




------------初始化
local config_table = ngx.shared.gcs_config   --声明ngx.shared.gcs_config
local ipshine_table = ngx.shared.gcs_ipshine   --声明ngx.shared.gcs_ipshine
local md5_check = ngx.shared.md5_check
local form_timeout = config_table:get("p_form_timeout")
local form_chunk_size = config_table:get("p_form_chunk_size")

local format = "jpg"
local model = "upload_hkkk"

local cjson_group = config_table:get("p_group_table")
local store_connect_timeout = config_table:get("p_store_connect_timeout")
local store_keep_timeout = config_table:get("p_store_keep_timeout")
local store_keep_count = config_table:get("p_store_keep_count")
local cjson_queue              = config_table:get("p_queue")
local remote_ip                = ngx.var.remote_addr              --获得客户端ip



--取时间最后2位 00-59
local sec = os.date("%S",ngx.time())
--取小时前2位 00-23
local hour = os.date("%H",ngx.time())
--取日期后2位00-31
local today = ngx.today()
local day = string.sub(today,-2)
---取月份
local mon = os.date("%Y%m",ngx.time())   --2014-08


-----------校验参数
local tb_parameters = {}
tb_parameters.form_timeout = form_timeout
tb_parameters.form_chunk_size = form_chunk_size
tb_parameters.store_connect_timeout = store_connect_timeout
tb_parameters.store_keep_timeout = store_keep_timeout
tb_parameters.store_keep_count = store_keep_count
tb_parameters.cjson_group = cjson_group

local check_parameters = {
  "store_keep_timeout",                 "store_keep_count",                "cjson_group"
}

local res,err,err_no = utils.check_parameter(tb_parameters,check_parameters)
err_utils.check_res(res,model,vssid,err,err_no,nil)

utils.gcs_log("debug",model .."second_line upload,check_parameter is ok")

---------------------------拼装信息----------------------------
---定义需要插入的字段放入table??
--local lkbh,time,Hphm,hpys,xssd,xsfx,cd,wfxwdm,hmsztpzb,csys,clpp,sbbh,tpmc
--local gfile,filename,vssid

---获取表单
local form,err = multipart:new(form_timeout,form_chunk_size)
utils.gcs_log("error","check form is err")
local form_res,err,err_no = up_utils.get_form_res(form)
local form_res = err_utils.check_res(form_res,model,vssid,err,err_no,nil)


---校验form_res中的???段是否存??
local res,err,err_no = up_utils.check_form_res(form_res)
err_utils.check_res(res,model,vssid,err,err_no,nil)

utils.gcs_log("debug",model .."check form_res is ok")

------------------------校验队列---------------------
local tb_queue,err,err_no = up_utils.get_queue(cjson_queue,remote_ip)  ---获取队列信息
local tb_queue = err_utils.check_res(tb_queue,model,vssid,err,err_no,nil)
utils.gcs_log("debug",model .."check queue is ok")



--解析data流 
local db_data={}
local str_data = form_res.data.value
local fpath,fname = up_utils.get_filename(str_data)
--解析fname

fname = up_utils.createIconv("gbk","utf-8",fname)--将gbk转成utf-8
utils.gcs_log("debug","文件名"  ..cjson.encode(fname))
db_data= up_utils.analysis_fname(fname) 
db_data.size = form_res.gfile1.file_size
db_data.md5 = form_res.gfile1.md5
db_data.lx = "kk"
db_data.wfxwdm=db_data.wfxwdmkk
db_data.wfxwdmkk=nil
db_data.wfxwdmdj=nil
local tpmc={db_data.lkbh,db_data.time,db_data.txxh,db_data.zpzs,
  db_data.zpxh,db_data.hphm,db_data.hpys,db_data.xssd,db_data.xsfx,
  db_data.cd,db_data.wfxwdm,db_data.hpsztpzb,db_data.csys,db_data.clpp,db_data.sbbh} 
db_data.tpmc=table.concat(tpmc,"-") 
utils.gcs_log("debug",model .."解析文件名成功")


------------------------------------------
---校验是否重复提交
--
if md5_check:get(db_data.md5) then 
    utils.gcs_log("debug",model .."重复提交")
    ngx.exit(200)
else
    md5_check:set(db_data.md5,1)
    utils.gcs_log("debug",model .."不是重复提交")
end 
-------------------------------------------
--过滤抓拍序号为3的
if tonumber(db_data.zpxh) == 3 then
  ngx.exit(200)
end


-------------------------------------------
---存入storage
--
local st_res=""
if db_data.wfxwdm~="00000" then 
    utils.gcs_log("debug",model .."进来的是违章车辆")
    st_res=up_utils.get_storage(cjson_group)
else
    st_res = up_utils.get_storage(cjson_group)
end
local tb_value={
  timeout = store_connect_timeout,
  keep_timeout = store_keep_timeout,
  keep_count = store_keep_count
}

local gfile,err,err_no = up_utils.save_storage(form_res,st_res,tb_value,format)
local gfile = err_utils.check_res(gfile,model,vssid,err,err_no,db_data.md5)
utils.gcs_log("debug",model .."存入storage成功")
db_data.gfile=gfile
db_data.server_ip = tb_queue.server_ip
db_data.str_res = cjson.encode(st_res)

-------------------------------------------------------------------------


-------------------------------------------------------------------------
--key的设置
local key2=db_data.sbbh .."_" ..db_data.txxh .."_1"  --第一张大图的key
local key1=db_data.sbbh .."_" ..db_data.txxh .."_1_plate"  --车牌的key
local key_2=db_data.sbbh .."_" ..db_data.txxh .."_2" --第二张大图的key
local key=up_utils.check_key(db_data,str_data) --判断进来的图片的key
local db_data1={}
------------------------------------------
--检查自身缓存

local res1,code,status=up_utils.pack_checkself(key,db_data)--检查自身缓存
err_utils.check_res(res,model,vssid,err,err_no,nil)
local mongo_table_name1="" --mongodb表名
local list="" --队列名
local numlist=""    --违章计数
if code==1 then --自身缓存不存在
    res1=db_data
else--自身缓存存在
    if status==1 then--缓存中的数据是历史数据
        db_data1=up_utils.pack_kk3(res1)
    else  --传过来的图片是历史数据
        db_data1=up_utils.pack_kk3(db_data)
    end
    local time1=string.sub(db_data1.time1,1,6)
    local mongo_table_name = "gcxx_" ..time1
    local mongo_table_namewz = "wzgcxx"
    if db_data1.wfxwdm~="00000" then
        mongo_table_name1=mongo_table_namewz
        list="wzlist"
        numlist="gc_wznumby"
    else 
        mongo_table_name1=mongo_table_name
        list=tb_queue.q_name   
    end  
    
-------------------------------------------------------------
--    存入mongodb和插入队列    
    local n,res=up_utils.pack_stor(db_data1,mongo_table_name1,list)
    err_utils.check_res(n,model,vssid,err,1402,nil)
    err_utils.check_res(res,model,vssid,err,1402,nil)
    utils.gcs_log("debug",model .."存入mongodb成功，插入" ..list .."队列成功")
-------------------------------------------------------------
--    计算流量，违章的车辆计数，路口计数，    
    if  numlist=="gc_wznumby"  then
        up_utils.ins_numbytime(numlist .."hour_" ,hour)--按小时计算违章过车数量
        up_utils.ins_numbytime(numlist .."day_" ,day)--按天数计算违章过车数量
        up_utils.ins_numbytime(numlist .."mon_" ,mon)--按月份计算违章过车数量
        up_utils.ins_numbytime(db_data1.lkbh .."_" ..numlist .."hour_",hour) --按小时计算路口违章过车数量
    end
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_numbyhour_",hour) --路口过车数量
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.hpzl .."car_numbyhour_" ,hour) --按小时计算路口大型车，小型车数量
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.clpz .."car_numbyhour_" ,hour)--按小时路口外地车，本地车数量
    up_utils.ins_numbytime("gc_numbyhour_" ,hour)--按小时计算过车流量
    up_utils.ins_numbytime("gc_numbyday_",day) --按天数计算过车流量
    up_utils.ins_numbytime("gc_numbymon_" ,mon)--按月份计算过车流量
    ngx.exit(200)    
end

-------------------------------
--开始打包
if key==key2 then --第一张大图
   
    local res2,code,status,err=up_utils.pack_checkred(key_2,key,db_data)--检查第二张大图缓存
    err_utils.check_res(res2,model,vssid,err,1402,nil)
    --检查第二张大图
    if code==0 then--第二张大图存在
        if status==0 then --存在并且是同一组
            if db_data.hphm=="无车牌" then --无车牌，2张打包
                db_data1=up_utils.pack_kk3(res1,res2)
                local tb_key={key,key_2}--清除缓存
                red_method.del_data(tb_key)
                utils.gcs_log("debug",model .."无车牌打包成功")
            else--有车牌，检查车牌缓存 
                local res3,code,status,err=up_utils.pack_checkred(key1,key,db_data)--检查车牌缓存
                err_utils.check_res(res3,model,vssid,err,err_no,nil)
                if code==0 then
                    if status==0 then --车牌存在并且是同一组
                        db_data1=up_utils.pack_kk3(res1,res2,res3)
                        local tb_key={key,key1,key_2}  --清除缓存
                        red_method.del_data(tb_key)
                        utils.gcs_log("debug",model .."打包结束，清理缓存")
                    elseif status==-1 then --缓存时间大于传过来的图片,传过来的图片是历史数据
                        db_data1=up_utils.pack_kk3(res1)
                    else--不是同一组，缓存时间小，缓存中的图片是历史数据
                        db_data1=up_utils.pack_kk3(res3)
                    end
                else
                    utils.gcs_log("debug",model .."没有车牌退出程序")
                    ngx.exit(200)
                end
            end
        elseif status==-1 then --缓存时间大，传过来的图片是历史数据
            db_data1=up_utils.pack_kk3(res1)
        else--第二张大图，缓存时间小，缓存中的图片是历史数据
            db_data1=up_utils.pack_kk3(res2)  
        end
    else--第二张大图不存在
        utils.gcs_log("debug",model .."第一张大图进来，没有第二张退出程序")
        ngx.exit(200)
    end
elseif key==key1 then --车牌
    --检查第一张大图的缓存
    local res2,code,status,err=up_utils.pack_checkred(key2,key,db_data)
    err_utils.check_res(res2,model,vssid,err,err_no,nil)
    
    if code==0 then
        if status==0 then
               --第一张大图存在  ， 检查第二张大图的缓存
            local res3,code,status,err=up_utils.pack_checkred(key_2,key,db_data)
            err_utils.check_res(res3,model,vssid,err,err_no,nil)
            if code==0 then--三张打包
                --存数据库，插队列
                if status==0 then
                    db_data1=up_utils.pack_kk3(res2,res3,res1)
                    local tb_key={key,key2,key_2}--清除缓存
                    red_method.del_data(tb_key)
                    utils.gcs_log("debug",model .."打包结束，清理缓存")
                elseif status==-1 then
                    db_data1=up_utils.pack_kk3(db_data)
                else
                    db_data1=up_utils.pack_kk3(res3)
                end
            else-- 第二张大图不存在
                utils.gcs_log("debug",model .."没有第二张退出程序")
                ngx.exit(200)
            end
        elseif status==-1 then --缓存时间大，传过来的图片是历史数据
            db_data1=up_utils.pack_kk3(res1)
        else--缓存时间小，缓存中图片是历史数据
            db_data1=up_utils.pack_kk3(res2)
        end
    else
      utils.gcs_log("debug",model .."车牌进来，没有第一张退出程序")
      ngx.exit(200)
    end
else 
    --检查第一张大图的缓存
    local res2,code,status,err=up_utils.pack_checkred(key2,key,db_data)
    err_utils.check_res(res2,model,vssid,err,err_no,nil)
    if code==0 then
        if status==0 then
            --第一张大图存在，检查其有无车牌 
            if res2.hphm~="无车牌" then
                --检查有没有车牌的缓存
                local res3,code,status,err=up_utils.pack_checkred(key1,key,db_data)
                err_utils.check_res(res3,model,vssid,err,1444,nil)
                if code==0 then
                    if status==0  then
                        --三张打包
                        --存入数据库，插入队列
                        db_data1=up_utils.pack_kk3(res2,res1,res3)
                        local tb_key={key,key2,key1}--清除缓存
                        red_method.del_data(tb_key)
                        utils.gcs_log("debug",model .."打包结束，清理缓存")
                    elseif status==-1 then --缓存时间大,传过来的图片是历史数据
                        db_data1=up_utils.pack_kk3(res1)
                    else --缓存时间小，缓存中的数据是历史数据
                        --存入数据库，插入历史队列
                        db_data1=up_utils.pack_kk3(res3)
                    end
                else
                    utils.gcs_log("debug",model .."没有车牌，退出程序")
                    ngx.exit(200)
                end
            else--无车牌
                --两张打包
                --存入数据库，插入队列
                db_data1=up_utils.pack_kk3(res2,res1)
                local tb_key={key,key2}--清除缓存
                red_method.del_data(tb_key)
            end
        elseif status==-1 then --缓存时间大,传过来的图片是历史数据
            db_data1=up_utils.pack_kk3(res1)
        else--缓存时间小，缓存中的图片是历史数据
           --存入数据库，插入队列
            db_data1=up_utils.pack_kk3(res2)
        end
    else
       utils.gcs_log("debug",model .."第二张大图进来，没有第一张大图")
       ngx.exit(200)
    end
end

---------------------------------------------------------------
--计算总流量，违章车辆，路口过车
err_utils.check_res(db_data1.time1,model,vssid,cjson.encode(db_data) ..cjson.encode(db_data.sbbh),1444,db_data.md5)
local time1=string.sub(db_data1.time1,1,6)
local mongo_table_name = "gcxx_" ..time1
local mongo_table_namewz = "wzgcxx"
if db_data1.wfxwdm~="00000" then
    mongo_table_name1=mongo_table_namewz
    list="wzlist"
    numlist="gc_wznumby"
    utils.gcs_log("debug",model .."违章车辆存储")
else 
    mongo_table_name1=mongo_table_name
    list=tb_queue.q_name  
end
local n,res=up_utils.pack_stor(db_data1,mongo_table_name1,list)
err_utils.check_res(n,model,vssid,err,1402,nil)
err_utils.check_res(res,model,vssid,err,1402,nil)
utils.gcs_log("debug",model .."存mongodb成功，插入" ..list .."队列成功")
if  numlist=="gc_wznumby"  then
    up_utils.ins_numbytime(numlist .."hour_" ,hour)--按小时计算违章过车数量
    up_utils.ins_numbytime(numlist .."day_" ,day)--按天数计算违章过车数量
    up_utils.ins_numbytime(numlist .."mon_" ,mon)--按月份计算违章过车数量
    up_utils.ins_numbytime(db_data1.lkbh .."_" ..numlist .."hour_",hour) --按小时计算路口违章过车数量
end
utils.gcs_log("debug","lobh_gc_numbyhour_")
up_utils.ins_numbytime(db_data1.lkbh .."_gc_numbyhour_",hour) --路口过车数量
up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.hpzl .."car_numbyhour_" ,hour) --按小时计算路口大型车，小型车数量
up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.clpz .."car_numbyhour_" ,hour)--按小时路口外地车，本地车数量
up_utils.ins_numbytime("gc_numbyhour_" ,hour)--按小时计算过车流量
up_utils.ins_numbytime("gc_numbyday_",day) --按天数计算过车流量
up_utils.ins_numbytime("gc_numbymon_" ,mon)--按月份计算过车流量

----------------------------------------------
--记录最后一条记录
--
local key = db_data.ip.."_enddata"
local ins_data = {}
ins_data[key] = cjson.encode(db_data1)
red_method.set_data(ins_data)

------返回正确代码
local tb_success = {}
tb_success.message = "upload is ok"
tb_success.vssid = db_data1.id
tb_success.code  = 200
ngx.say(cjson.encode(tb_success))


utils.gcs_log("info","pack is over")